﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<list>
#include<string>
#include<algorithm>
#include <windows.h>
#include <cstdio>
#include<thread>

using namespace std;



//class Person
//{
//public:
//		void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//protected:
//	string _name = "";  
//    string _address;
//	string _tel;
//	int _age = 18;
//};
//
//class Studet : public Person
//{
//public:
//	// 学习
//
//	void study()
//	{
//		// ...
//	}
//protected:
//	int _stuid;
//};
//
//class Teacher : public Person
//{
//public:
//
//		void teaching()
//	{
//		//...
//	}
//protected:
//	string title;
//};
//
//void test1()
//{
//	Studet s;
//	Teacher t;
//
//	s.identity();
//	t.identity();
//}
//
//namespace zh
//{
//	template<class T>
//	class stack : public std::vector<T>
//	{
//
//	public:
//		void push(const T& x)
//		{
//			// ⽗类是类模板时，需要指定⼀下类域，
//		    // 否则编译报错: error C3861 : “push_back”:找不到标识符
//		    // 因为stack<int>实例化时，也实例化vector<int>了
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			vector<T>::push_back(x);
//		}
//		
//	private:
//
//	};
//}
//
//void test2()
//{
// ⽗类和⼦类对象赋值兼容转换
//	Studet s;
//	// 1.⼦类对象可以赋值给⽗类对象/指针/引⽤
//	Person pobj = s;
//	Person* pp = &s;
//	Person& rp = s;
//
//	//2.父类对象不可以赋值给子类
//	//s = pobj;
//}

class A
{
public:
	void Print()
	{
		cout << _num << endl;
	}

protected:
	int _num = 10;
};

class B : public A
{
public:
	void Print()
	{
		cout << _num << endl;
	}

protected:
	int _num = 100;
};

void test3()
{
	//继承体系中⽗类和⼦类都有独⽴的作⽤域
	B b;
	//同名变量或函数都构成隐藏
	b.Print(); //父类的_num被子类的_num隐藏了
	b.A::Print();//显示调用
}

class Person
{
public:
	Person(const char* name = "")
		:_name(name)
	{}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}

protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num)
		:Person(name)
		,_num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)                         //⽗类和⼦类对象赋值兼容转换
		,_num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			// 构成隐藏，所以需要显⽰调⽤

			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}

	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num;
};

void test4()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
}

//int main()
//{
//	string str;
//	//getline(cin, str);
//
//	char ch;
//	while (cin >> ch)
//	{
//		str += ch;
//	}
//	cout << str << endl;
//
//	
//	return 0;
//}

struct TreeNode
{
	char val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(char val = -1, TreeNode* left = nullptr,
		TreeNode* right = nullptr)
		:val(val)
		, left(left)
		, right(right)
	{}
};

TreeNode* PrevOrderCreate(string str, int& i)
{
	if (str[i] == '#')
	{
		i++;
		return nullptr;
	}

	auto root = new TreeNode(str[i++]);
	root->left = PrevOrderCreate(str, i);
	root->right = PrevOrderCreate(str, i);
	return root;
}

void InOrder(TreeNode* root)
{
	if (root == nullptr) return;

	InOrder(root->left);
	cout << root->val << " ";
	InOrder(root->right);
}

//int main() {
//	//string str;
//	//char ch;
//	////cin >> ch
//	//ch = cin.get();
//	//while (ch != ' ' && ch != '\n')
//	//{	
//	//	str += ch;
//	//	cin >> ch;
//	//	ch = cin.get();
//	//	cout << str << endl;
//	//}
//	//cout << str << endl;
//
//	/*while (cin >> str)
//	{
//		cout << str << endl;
//	}*/
//	//cout << ch << endl;
//
//	//char ch;
//	//ch = cin.get();
//	//cout << ch << endl;
//	//cout << fflush;
//	//td::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
//	//fflush(stdin);
//	//
//	//while (getchar() != '\n');
//	//cin.ignore();
//	//cin.sync();
//	//fflush(stdin);
//
//	//string str;
//	//cin >> str;
//	//cout << str << endl;
//
//	/*cout << "hello";
//	Sleep(2000);*/
//
//	// 向标准输出写入一些文本
//	//std::cout << "Hello, ";
//	//std::this_thread::sleep_for(std::chrono::seconds(10));
//
//	// 此时，文本 "Hello, " 被写入到输出缓冲区，但并没有立即输出到控制台
//	// 因为缓冲区可能还没有满，也没有遇到换行符或其他刷新缓冲区的操作
//
//	// 假设程序在这里暂停或进行了其他操作
//	// 缓冲区中的 "Hello, " 仍然没有被输出
//
//	// 为了确保 "Hello, " 被输出，可以使用 std::flush 强制刷新缓冲区
//	//std::cout << std::flush;
//
//	// 或者使用 C 语言的 fflush 函数刷新 stdout 的缓冲区
//	//fflush(stdout); // 这会刷新 stdout 的缓冲区，确保 "Hello, " 被输出
//
//	// 程序继续执行
//	//std::cout << "World!" << std::endl; // 这将刷新缓冲区并输出 "World!" 和换行符
//
//
//	return 0;
//}

int main()
{
	//std::cout << "the normal one! " << std::endl;
	std::cout << "the test! ";
	Sleep(20000);
	//std::cout << "the test is over" << std::endl;

	return 0;
}